package gob.cgr.web.sgrh.managed;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import gob.cgr.sgrh.ejb.entidad.AdmGrado;
import gob.cgr.sgrh.ejb.entidad.CondicionEstudio;
import gob.cgr.sgrh.ejb.entidad.DatoFamiliar;
import gob.cgr.sgrh.ejb.entidad.Docencia;
import gob.cgr.sgrh.ejb.entidad.EstudioBasico;
import gob.cgr.sgrh.ejb.entidad.EstudioProfesional;
import gob.cgr.sgrh.ejb.entidad.FormacionLaboral;
import gob.cgr.sgrh.ejb.entidad.MovimientoDePersonal;
import gob.cgr.sgrh.ejb.entidad.Persona;
import gob.cgr.sgrh.ejb.entidad.Personal;
import gob.cgr.sgrh.ejb.entidad.Puesto;
import gob.cgr.sgrh.ejb.entidad.UnidadOrganica;
import gob.cgr.web.sgrh.component.Ubigeo;
import gob.cgr.web.sgrh.service.SigerhService;
import gob.cgr.web.sgrh.util.Utilitario;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.context.FacesContext;
import javax.faces.event.ValueChangeEvent;
import javax.inject.Inject;
import javax.servlet.http.HttpSession;

import org.primefaces.event.FileUploadEvent;
import org.primefaces.event.ItemSelectEvent;
import org.primefaces.event.SelectEvent;
import org.primefaces.model.DefaultStreamedContent;
import org.primefaces.model.StreamedContent;
import org.primefaces.model.UploadedFile;

@SessionScoped
@ManagedBean
public class PersonalMB {
	@Inject
	private SigerhService service;

	private Personal colaborador;
	// private Personal personalSelected;

	@Inject
	private Ubigeo ambito;
	@Inject
	private Ubigeo ambito2;
	private StreamedContent foto;
	private File fotoOriginal;
	private UploadedFile file;
	private String mensaje;
	private Date fechaCese;
	private String estado;
	private String motivoCese;
	private String estadoCivil;
	private String estudios;
	private String nroHijos;
	private String emailCorp;
	private String checkPage;
	private String nivelEstudio;
	private DatoFamiliar familiar;
	private FormacionLaboral experiencia;
	private FormacionLaboral experienciaSelected;
	private DatoFamiliar familiarSelected;
	private List<DatoFamiliar> familiares = new ArrayList<DatoFamiliar>();
	private List<FormacionLaboral> experiencias = new ArrayList<FormacionLaboral>();
	private boolean famVive;
	private EstudioBasico estudioBasico;
	private EstudioProfesional profesion;
	private EstudioBasico estudioBasicoSelected;
	private EstudioProfesional profesionSelected;
	//private EstudioProfesional colegiatura;
	private List<EstudioBasico> estudiosBasicos;
	private List<EstudioProfesional> estudiosProfesionales;
	private List<Docencia> docencias;
	private Docencia docencia;
	private List<MovimientoDePersonal> movimientos;
	private MovimientoDePersonal movimientoPersonal;
	private String idCargoActual;
	private List<Puesto> listaPuesto;
	private String uoUltimo;
	private String puestoUltimo; 
	private String estadoActual;
	
	

	
	public PersonalMB() {
		// TODO Auto-generated constructor stub
	System.out.println("personalMB created and reset....");
		reset();

	}

	// metodo para iniciar valores al cargar la pagina
	public void iniciar() {
		/*reset valores iniciales*/
		mensaje = null;
		motivoCese="";
		nroHijos="";
		fechaCese=null;
		familiarSelected=null;
		profesionSelected=null;
		estudioBasicoSelected=null;
		foto=null;
		fotoOriginal=null;
		/*fin reset*/
		
		
		if(colaborador.getIdPersonal()!=null){
			cargarPersonalCompleto();
			nuevoMovimiento();
			
		}else{
			if(colaborador.getIdPersona()!=null &&colaborador.getIdPersona().getIdPersona()!=null){
			Persona per=service.cargarPersonaCompleta(colaborador.getIdPersona().getIdPersona());
			estudiosBasicos=per.getEstudioBasicoList();
			estudiosProfesionales=per.getEstudioProfesionalList();
			colaborador.setIdPersona(per);
			}
			
		}
		listarMovimientos();
		loadFotoOriginal();
		nuevoFamiliar();
		listarDocencias();
		if (colaborador.getIdPersona() != null) {
			
			System.out.println("seteando el ambito "
					+ colaborador.getIdPersona().getLugarNacimiento());
			ambito.setearUbigeo(colaborador.getIdPersona().getLugarNacimiento());
		}
		
		
	}

	public void nuevoMovimiento(){
		movimientoPersonal=new MovimientoDePersonal();
		movimientoPersonal.setIdUnidadOrganica(new UnidadOrganica());
		movimientoPersonal.setIdPuesto(new Puesto());
	}
	
	private void cargarPersonalCompleto() {
		nivelEstudio="Basico";
		colaborador = service.cargarDatosCompletos(colaborador);
		estudiosBasicos=colaborador.getIdPersona().getEstudioBasicoList();
		estudiosProfesionales=colaborador.getIdPersona().getEstudioProfesionalList();
		int hijos=0;
		for(DatoFamiliar d:colaborador.getDatoFamiliarList()){
			if(d.getParentezco().equals("2"))//hijos
				hijos++;
		}
		nroHijos=hijos+"";
		for(EstudioProfesional e:colaborador.getIdPersona().getEstudioProfesionalList()){
			estudios=e.getEspecialidad();
			nivelEstudio="Profesional";
			break;
		}
	}

	private void reset() {

		colaborador = new Personal();
		colaborador.setIdPersona(new Persona());
		nuevoFamiliar();
		nuevoMovimiento();
		familiares = new ArrayList<DatoFamiliar>();
		nuevaFormacionLaboral();
		// ambito=new Ubigeo();
		mensaje = null;
		motivoCese="";
		nroHijos="";
		fechaCese=null;
		familiarSelected=null;
		profesionSelected=null;
		estudioBasicoSelected=null;
		foto=null;
		fotoOriginal=null;

	}

	public void listarDocencias(){
		if(colaborador.getIdPersona().getIdPersona()!=null)
		docencias=service.listarDocencias(colaborador.getIdPersona().getIdPersona());
		
	}
	
	public void listarExperiencias(){
		if(colaborador.getIdPersona().getIdPersona()!=null)
		experiencias=service.listarFormacionLaboralPersona(colaborador.getIdPersona().getIdPersona());
	}
	

	
	
	public void preVerificarNuevo(){
		System.out.println("obteniendo la edad");
		if (colaborador.getIdPersona().getEdad() < 18) {
			mensaje = "El personal debe ser mayor de edad";
			Utilitario.mostrarMensajeAlerta("El personal debe ser mayor de edad");
			System.out.println("mensaje: "+mensaje);
			return;
		}
		
	}
	
	
	
	public void guardar() {
		System.out.println("persona es " + colaborador.getIdPersona());
		colaborador.getIdPersona().setLugarNacimiento(
				ambito.getAmbitoSelected());
		if (colaborador.getIdPersona().getEdad() < 18) {
			mensaje = "El personal debe ser mayor de edad";
			Utilitario.mostrarMensajeAlerta("El personal debe ser mayor de edad");
			return;
		}
		System.out.println("obtenido el ambito");
		colaborador.setFoto(saveFoto());
		try {
			if (Utilitario.isNullOrEmpty(colaborador.getCodigoPersonal())) {
				System.out.println("registrando nueva personal");
				if(movimientoPersonal==null){
					mostrarMensajeAlerta("Debe Ingresar el primer movimiento del personal para su fecha de ingreso");
					return;
				}	
				List<MovimientoDePersonal> m=new ArrayList<MovimientoDePersonal>();
				m.add( movimientoPersonal);
				colaborador.setFechaIngreso(movimientoPersonal.getIngreso());
				estado="ACTIVO";
				colaborador.setMovimientoDePersonalList(m);
				colaborador=service.registrarPersonal(colaborador);
				iniciar();
			} else {
				System.out.println("actualizando personal existente");
				service.actualizarPersonal(colaborador);
			}
			mensaje = "La operacion se realizo con exito";
		} catch (Exception e) {
			// TODO: handle exception
			mensaje = "Ocurrio un error en la operacion :" + e.getMessage();
		}

	}

	public String cancelar() {
		reset();
		HttpSession session = (HttpSession) FacesContext.getCurrentInstance()
			    .getExternalContext().getSession(true);
			    session.removeAttribute("personalMB");

		
		return "cancelar";
	}

	public Ubigeo getAmbito() {
		return ambito;
	}

	public void setAmbito(Ubigeo ambito) {
		this.ambito = ambito;
	}

	public Ubigeo getAmbito2() {
		return ambito2;
	}

	public void setAmbito2(Ubigeo ambito2) {
		this.ambito2 = ambito2;
	}

	public Personal getColaborador() {
		return colaborador;
	}

	public void setColaborador(Personal colaborador) {
		this.colaborador = colaborador;
	}

	public StreamedContent getFoto() {
		// System.out.println("FOTO ES "+foto);
	//	System.out.println("file es :" + file);
		//System.out.println("fotoOriginal  es: " + fotoOriginal);
		try {
			if (fotoOriginal == null)
				foto = new DefaultStreamedContent(file.getInputstream());// ,
																			// "image/jpeg");
			else{
				loadFotoOriginal();
				InputStream is=new FileInputStream(fotoOriginal);
				
				foto = new DefaultStreamedContent(is);// , "image/jpeg");
			
				
			}
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println("error al recargar la imagen " + e.getMessage());
			return null;
		}

		return foto;
	}

	public void setFoto(StreamedContent foto) {
		this.foto = foto;
	}

	public void handleFileUpload(FileUploadEvent e) {
		try {
			file = e.getFile();
			foto = new DefaultStreamedContent(file.getInputstream());// ,
																		// "image/jpeg");
			fotoOriginal = null;
		} catch (Exception ex) {
			System.out.println(ex.getMessage());
		}
	}

	/*
	 * public Personal getPersonalSelected() { return personalSelected; }
	 * 
	 * public void setPersonalSelected(Personal personalSelected) {
	 * this.personalSelected = personalSelected; }
	 */

	public String getMensaje() {
		return mensaje;
	}

	public void setMensaje(String mensaje) {
		this.mensaje = mensaje;
	}

	private String saveFoto() {
		if (getFoto() == null)
			return null;
		try {
			if(fotoOriginal!=null){ //es la misma foto asi es que no lo guardamos
				return colaborador.getFoto();
			}			
			
			String newFileName = colaborador.getIdPersona()
					.getApellidoPaterno()
					+ "_"
					+ colaborador.getIdPersona().getApellidoMaterno()
					+ "_"
					+ colaborador.getIdPersona().getNroDocumento()+ ".jpg";
			System.out.println("fileName: " + newFileName);
			File fotoAguardar = new File(Utilitario.getCarpetaFoto()
					+ newFileName);
			if(fotoAguardar.exists()){
				fotoAguardar.delete();
			}
			
			
			System.out.println("file " + fotoAguardar.getAbsolutePath());
			FileOutputStream fos = new FileOutputStream(fotoAguardar);
			InputStream is = getFoto().getStream();
			int BUFFER_SIZE = 8192;
			byte[] buffer = new byte[BUFFER_SIZE];
			int a;
			while (true) {
				a = is.read(buffer);
				if (a < 0)
					break;
				fos.write(buffer, 0, a);
				fos.flush();
			}
			fos.close();
			is.close();
			System.out.println("se guardo la foto ");
			return newFileName;
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println("error al guardar la foto " + e.getMessage());
			return null;
		}

	}

	private void loadFotoOriginal() {
		if (colaborador.getFoto() != null)
			try {
				System.out.println("cargando la foto original");
				fotoOriginal = new File(Utilitario.getCarpetaFoto()
						+ colaborador.getFoto());
				System.out.println("::::cargado la foto original "+fotoOriginal);
			} catch (Exception e) {
				// TODO: handle exception
				System.out.println("error al cargar la foto original "
						+ fotoOriginal + "  " + e.getMessage());
			}

	}

	public void mostrarMensajeAlerta(String msj) {
		FacesContext.getCurrentInstance().addMessage(null,
				new FacesMessage(FacesMessage.SEVERITY_WARN, "Alerta", msj));
	}

	public void mostrarMensajeExito(String msj) {
		FacesContext.getCurrentInstance().addMessage(
				null,
				new FacesMessage(FacesMessage.SEVERITY_INFO, "Confirmacion OK",
						msj));
	}

	public Date getFechaCese() {
		return fechaCese;
	}

	public void setFechaCese(Date fechaCese) {
		this.fechaCese = fechaCese;
	}

	public String getEstado() {
		return estado;
	}

	public void setEstado(String estado) {
		this.estado = estado;
	}

	public String getMotivoCese() {
		return motivoCese;
	}

	public void setMotivoCese(String motivoCese) {
		this.motivoCese = motivoCese;
	}

	public String getEstadoCivil() {
		return estadoCivil;
	}

	public void setEstadoCivil(String estadoCivil) {
		this.estadoCivil = estadoCivil;
	}

	public String getEstudios() {
		return estudios;
	}

	public void setEstudios(String estudios) {
		this.estudios = estudios;
	}

	public String getNroHijos() {
		return nroHijos;
	}

	public void setNroHijos(String nroHijos) {
		this.nroHijos = nroHijos;
	}

	public String getEmailCorp() {
		return emailCorp;
	}

	public void setEmailCorp(String emailCorp) {
		this.emailCorp = emailCorp;
	}

	public void check() {
		if (checkPage == null) {
			System.out
					.println("uyyyyyyy, esta pagina se ha cargado sin ser llamada desde la busqueda");
			FacesContext fc = FacesContext.getCurrentInstance();
			fc.getApplication().getNavigationHandler()
					.handleNavigation(fc, null, "admInformacion");
			//Utilitario.redirect("informacion-personal", null);

		}

	}

	public String getCheckPage() {
		return checkPage;
	}

	public void setCheckPage(String checkPage) {
		this.checkPage = checkPage;
	}

	public DatoFamiliar getFamiliar() {
		return familiar;
	}

	public void setFamiliar(DatoFamiliar familiar) {
		this.familiar = familiar;
	}

	public void guadarFamiliar() {
		try {
			System.err.println("llamado a guardar");

			familiar.getIdPersona().setLugarNacimiento(
					ambito2.getAmbitoSelected());
			service.agregarFamiliar(familiar);
			System.out.println("familiar guardado id "
					+ familiar.getIdDatoFamiliar());
			nuevoFamiliar();
			cargarPersonalCompleto();
			mostrarMensajeExito("Se ha actualizado la informacion correctamente");
		} catch (Exception e) {
			// TODO: handle exception
			mostrarMensajeAlerta("No se pudo guardar el dato familiar, "
					+ e.getMessage());
		}

	}

	public boolean isFamVive() {
		famVive = ("S").equals(familiar.getVive()) ? true : false;
		return famVive;
	}

	public void setFamVive(boolean famVive) {
		familiar.setVive(famVive ? "S" : "N");
		this.famVive = famVive;
	}

	public List<DatoFamiliar> getFamiliares() {
		familiares = colaborador.getDatoFamiliarList();
//		System.out.println("datos familiares " + familiares.size());
		return familiares;
	}

	public void setFamiliares(List<DatoFamiliar> familiares) {
		this.familiares = familiares;
	}

	public void nuevoFamiliar() {
		familiar = new DatoFamiliar();
		familiar.setIdPersona(new Persona());
		familiar.setIdPersonal(colaborador);
		familiar.setVive("S");
		familiarSelected=null;
	}

	public void eliminarFamiliar() {
		try {
			if (familiarSelected.getIdDatoFamiliar() != null) {
				service.quitarFamiliar(familiarSelected);
				mostrarMensajeExito("El familiar ha sido eliminado");
				nuevoFamiliar();
				cargarPersonalCompleto();
			}
		} catch (Exception e) {
			mostrarMensajeAlerta("No se pudo eliminar el familiar asociado "
					+ e.getMessage());
		}

	}

	public DatoFamiliar getFamiliarSelected() {
		return familiarSelected;
	}

	public void setFamiliarSelected(DatoFamiliar familiarSelected) {
		this.familiarSelected = familiarSelected;
	}

	public void onRowSelect(SelectEvent event) {
		DatoFamiliar fam = ((DatoFamiliar) event.getObject());
		famVive = ("S").equals(fam.getVive()) ? true : false;
		ambito2.setearUbigeo(fam.getIdPersona().getLugarNacimiento());

		// System.out.println("seteado con el ambito "+ambito2.getAmbitoSelected());
		// System.out.println("recibiendo de :::"+event.getSource().toString());
		// FacesMessage msg = new FacesMessage(" Selected", ((DatoFamiliar)
		// event.getObject()).getIdPersona().getNombreCompleto());
		// FacesContext.getCurrentInstance().addMessage(null, msg);
	}

	public void nuevaFormacionLaboral() {
		experiencia = new FormacionLaboral();
		experiencia.setIdPersona(colaborador.getIdPersona());
		experienciaSelected=null;
	}
	
	public void nuevoEstudioBasico(){
		estudioBasico=new EstudioBasico();
		estudioBasico.setIdPersona(colaborador.getIdPersona());
		estudioBasicoSelected=null;
	}
	
	public void nuevoEstudioProfesional(){
		profesion=new EstudioProfesional();
		profesion.setIdPersona(colaborador.getIdPersona());
		profesion.setIdAdmGrado(new AdmGrado());
		profesion.setIdCondEstudio(new CondicionEstudio());
		profesionSelected=null;
		
	}

	public FormacionLaboral getExperiencia() {
		return experiencia;
	}

	public void setExperiencia(FormacionLaboral experiencia) {

		this.experiencia = experiencia;
	}

	public List<FormacionLaboral> getExperiencias() {
	//	experiencias = colaborador.getIdPersona().getFormacionLaboralList();
		return experiencias;
	}

	public void setExperiencias(List<FormacionLaboral> experiencias) {
		this.experiencias = experiencias;
	}

	public void actualizarFormacionLaboral() {
		System.out.println("llamdo al acutalizar");
		if (experiencia != null) {
			if (experiencia.getDesde().after(experiencia.getHasta())) {
				mostrarMensajeAlerta("la fecha inicial debe ser menor a la final");
				return;
			}
			try {
				service.agregarFormacionLaboral(experiencia);
				mostrarMensajeExito("Se ha actualizado la formacion laboral del Colaborador");
				nuevaFormacionLaboral();
				listarExperiencias();
			} catch (Exception e) {
				// TODO: handle exception
				mostrarMensajeAlerta("No se pudo actualizar la formacion laboral del colaborador :"
						+ e.getMessage());
			}

		}

	}

	public void eliminarFormacionLaboral() {
		if (experienciaSelected != null) {
			try {
				service.quitarFormacionLaboral(experienciaSelected);
				mostrarMensajeExito("Se ha eliminado la formacion laboral elegida del Colaborador");
				nuevaFormacionLaboral();
				cargarPersonalCompleto();
			} catch (Exception e) {
				// TODO: handle exception
				mostrarMensajeAlerta("No se pudo eliminar la formacion laboral del colaborador :"
						+ e.getMessage());
			}

		}

	}

	public void nuevaDocencia(){
		docencia=new Docencia();
		
		
	}
	
	public void actualizarDocencia(){
		try {
			docencia.setIdPersona(colaborador.getIdPersona());
			service.agregarDocencia(docencia);
			listarDocencias();
			Utilitario.mostrarMensajeExito("La operacion se ha realizado correctamente");
		} catch (Exception e) {
			// TODO: handle exception
			Utilitario.mostrarMensajeAlerta("Ocurrio un error al intentar actualizar la docencia "+e.getMessage());
		}
		
	}
	
	public void eliminarDocencia(){
		System.out.println("eliminando docencias" );
			if(docencia.getIdDocencia()==null){
				Utilitario.mostrarMensajeAlerta("No se ha elegido una docencia a eliminar");return;	
			}
		try {
			service.quitarDocencia(docencia);
			listarDocencias();
			Utilitario.mostrarMensajeExito("La operacion se ha realizado correctamente");
		} catch (Exception e) {
			// TODO: handle exception
			Utilitario.mostrarMensajeAlerta("Ocurrio un error al intentar actualizar la docencia "+e.getMessage());
		}
		
	}
	
	

	public EstudioBasico getEstudioBasico() {
		return estudioBasico;
	}

	public void setEstudioBasico(EstudioBasico estudioBasico) {
		this.estudioBasico = estudioBasico;
	}

	public EstudioProfesional getProfesion() {
		return profesion;
	}

	public void setProfesion(EstudioProfesional profesion) {
		this.profesion = profesion;
	}

	public void actualizarEstudioBasico() {
		if (estudioBasico != null) {
			try {
				service.agregarEstudiosBasicos(estudioBasico);
				mostrarMensajeExito("Se ha actualizado la Estudio Basico del Colaborador");
				nuevoEstudioBasico();
				cargarPersonalCompleto();
			} catch (Exception e) {
				// TODO: handle exception
				mostrarMensajeAlerta("No se pudo actualizar el Estudio Basico del colaborador :"
						+ e.getMessage());
			}

		}

	}

	public void eliminarEstudioBasico(){
		System.out.println("eliminando estudio basico");
		if (estudioBasicoSelected != null) {
			try {
				service.quitarEstudiosBasicos(estudioBasicoSelected);
				mostrarMensajeExito("Se ha eliminado el Estudio Basico elegido del Colaborador");
				nuevoEstudioBasico();
				cargarPersonalCompleto();
			} catch (Exception e) {
				// TODO: handle exception
				mostrarMensajeAlerta("No se pudo eliminar  el Estudio Basico del colaborador :"
						+ e.getMessage());
			}

		}
	}

	public void actualizarEstudioProfesional() {
		if (profesion != null) {
			try {
				service.agregarEstudiosProfesionales(profesion);
				mostrarMensajeExito("Se ha actualizado la profesion del Colaborador");
				nuevoEstudioProfesional();
				cargarPersonalCompleto();
			} catch (Exception e) {
				// TODO: handle exception
				mostrarMensajeAlerta("No se pudo actualizar la profesion del colaborador :"
						+ e.getMessage());
			}

		}

	}

	public void eliminarEstudioProfesional(){
		//System.out.println("eliminando estudio profesional");
		if (profesionSelected != null) {
			try {
				service.quitarEstudiosProfesionales(profesionSelected);
				mostrarMensajeExito("Se ha eliminado el Estudio Profesional elegido del Colaborador");
				nuevoEstudioProfesional();
				cargarPersonalCompleto();
			} catch (Exception e) {
				// TODO: handle exception
				mostrarMensajeAlerta("No se pudo eliminar  el Estudio Profesional del colaborador :"
						+ e.getMessage());
			}

		}
	}
	
	
	public List<EstudioBasico> getEstudiosBasicos() {
		
		return estudiosBasicos;
	}

	public void setEstudiosBasicos(List<EstudioBasico> estudiosBasicos) {
		this.estudiosBasicos = estudiosBasicos;
	}

	public List<EstudioProfesional> getEstudiosProfesionales() {
		//estudiosProfesionales=colaborador.getIdPersona().getEstudioProfesionalList();
		return estudiosProfesionales;
	}

	public void setEstudiosProfesionales(List<EstudioProfesional> estudiosProfesionales) {
		this.estudiosProfesionales = estudiosProfesionales;
	}

	public List<MovimientoDePersonal> getMovimientos() {
		return movimientos;
	}

	public void setMovimientos(List<MovimientoDePersonal> movimientos) {
		this.movimientos = movimientos;
	}

	public MovimientoDePersonal getMovimientoPersonal() {
		return movimientoPersonal;
	}

	public void setMovimientoPersonal(MovimientoDePersonal movimientoPersonal) {
		this.movimientoPersonal = movimientoPersonal;
	}

	public String getIdCargoActual() {
		return idCargoActual;
	}

	public void setIdCargoActual(String idCargoActual) {
		this.idCargoActual = idCargoActual;
	}

	public List<Puesto> getListaPuesto() {
		return listaPuesto;
	}

	public void setListaPuesto(List<Puesto> listaPuesto) {
		this.listaPuesto = listaPuesto;
	}
	
	public void cargarPuesto(ValueChangeEvent  e){
		Object o=e.getNewValue();
		if(o!=null && !o.toString().equals("")){
			listaPuesto=service.listarPuestosPorUnidadOrganica(Integer.valueOf(o.toString()));
		}
	}
	
	private void listarMovimientos(){
		if(colaborador!=null && colaborador.getIdPersonal()!=null){
		movimientos=service.listarMovimientosPersonal(colaborador.getIdPersonal());
		for(MovimientoDePersonal m:movimientos){
			puestoUltimo= m.getIdPuesto().getNombre();
			uoUltimo=m.getIdUnidadOrganica().getNombreUnidad();
			estadoActual=m.getSalida()==null?"ACTIVO":"CESADO";
			estado=estadoActual;
			colaborador.setEstado(estado);
			break;
		}
	}
	}
	
	
	public void cesarColaborador(){
		if(colaborador!=null && colaborador.getIdPersonal()!=null && movimientos.size()>0){
			MovimientoDePersonal mov=movimientos.get(0);
						mov.setSalida(fechaCese);
						mov.setMotivo(motivoCese);
				try {
					service.actualizarMovimientoPersonal(mov);
					listarMovimientos();
					Utilitario.mostrarMensajeExito("La operaci&oacute;n se realizado correctamente");
				} catch (Exception e) {
					// TODO: handle exception
					Utilitario.mostrarMensajeAlerta("No se pudo realizar la operacion "+e.getMessage());
				}		
						
						
		}
	}
	
	public void actualizarMovimiento(){
		try {
			System.out.println("actualizando el movimiento");
			movimientoPersonal.setIdPersonal(colaborador);
			service.actualizarMovimientoPersonal(movimientoPersonal);
			listarMovimientos();
			service.actualizarPersonal(colaborador);
			Utilitario.mostrarMensajeExito("Se ha actualizado la informacion Laboral del colaborador");
		} catch (Exception e) {
			// TODO: handle exception
			Utilitario.mostrarMensajeAlerta("Ocurrio un error al actualizar el movimiento del personal "+e.getMessage());
		}
		
		
	}

	
	public String getUoUltimo() {
		return uoUltimo;
	}

	public void setUoUltimo(String uoUltimo) {
		this.uoUltimo = uoUltimo;
	}

	public String getPuestoUltimo() {
		return puestoUltimo;
	}

	public void setPuestoUltimo(String puestoUltimo) {
		this.puestoUltimo = puestoUltimo;
	}

	public String getEstadoActual() {
		return estadoActual;
	}

	public void setEstadoActual(String estadoActual) {
		this.estadoActual = estadoActual;
	}

	public List<Docencia> getDocencias() {
		return docencias;
	}

	public void setDocencias(List<Docencia> docencias) {
		this.docencias = docencias;
	}

	public Docencia getDocencia() {
		return docencia;
	}

	public void setDocencia(Docencia docencia) {
		this.docencia = docencia;
	}

	public String getNivelEstudio() {
		return nivelEstudio;
	}

	public void setNivelEstudio(String nivelEstudio) {
		this.nivelEstudio = nivelEstudio;
	}

	public EstudioBasico getEstudioBasicoSelected() {
		return estudioBasicoSelected;
	}

	public void setEstudioBasicoSelected(EstudioBasico estudioBasicoSelected) {
		this.estudioBasicoSelected = estudioBasicoSelected;
	}

	public EstudioProfesional getProfesionSelected() {
		return profesionSelected;
	}

	public void setProfesionSelected(EstudioProfesional profesionSelected) {
		this.profesionSelected = profesionSelected;
	}
	
	public void editarFamiliar(){
		System.out.println("familiar Selected"+familiarSelected);
		familiar=familiarSelected;
		ambito2.setearUbigeo(familiar.getIdPersona().getLugarNacimiento());
		
	}
	public void editarExperiencia(){
		System.out.println("experienciaSelected :"+experienciaSelected);
		experiencia=experienciaSelected;
	}
	public void editarEstudioBasico(){
		estudioBasico=estudioBasicoSelected;
	}
	public void editarEstudioProf(){
		profesion=profesionSelected;
	}

	public FormacionLaboral getExperienciaSelected() {
		return experienciaSelected;
	}

	public void setExperienciaSelected(FormacionLaboral experienciaSelected) {
		this.experienciaSelected = experienciaSelected;
	}
	
	public void verificarExistenciaPersona(){
		if(familiar!=null){
			if(checkDNIFamiliar(familiar.getIdPersona().getNroDocumento())){
				mostrarMensajeAlerta("El DNI corresponde al propio trabajador");
				familiar.getIdPersona().setNroDocumento(null);
				return;
			}
		Persona p=service.buscarPersona(familiar.getIdPersona().getNroDocumento());
		if(p!=null){
			familiar.setIdPersona(p);
			ambito2.setearUbigeo(p.getLugarNacimiento());
			}
		}
		if(familiarSelected!=null){
			if(checkDNIFamiliar(familiarSelected.getIdPersona().getNroDocumento())){
				mostrarMensajeAlerta("El DNI corresponde al propio trabajador");
				familiarSelected.getIdPersona().setNroDocumento(null);
				return;
			}
			Persona p=service.buscarPersona(familiarSelected.getIdPersona().getNroDocumento());
			if(p!=null){
				familiarSelected.setIdPersona(p);
				ambito2.setearUbigeo(p.getLugarNacimiento());
			}
			}
		System.out.println("fin del metodo");
	}
	
	private boolean checkDNIFamiliar(String dni){
		if(colaborador.getIdPersona().getNroDocumento().equals(dni))
			return true;
		else
			return false;
		
	}
}
